package puyu.manage.service.role.service.impl;

import cn.hutool.core.util.ObjectUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import puyu.manage.service.common.dao.CommonMapper;
import puyu.manage.service.role.entity.SysRole;
import puyu.manage.service.role.dao.SysRoleMapper;
import puyu.manage.service.role.service.SysRoleServiceI;
import puyu.manage.service.utils.StringUtils;
import puyu.manage.service.utils.UserConstants;
import puyu.manage.service.utils.except.CustomException;

import java.util.*;

/**
 * 角色 业务层处理
 *
 * @author cxnet
 */
@Service
public class SysRoleServiceIImpl implements SysRoleServiceI {
    @Autowired(required = false)
    private SysRoleMapper roleMapper;


    @Autowired(required = false)
    private CommonMapper commonMapper;
    /**
     * 根据条件分页查询角色数据
     *
     * @param role 角色信息
     * @return 角色数据集合信息
     */
    @Override
//    @DataScope(deptAlias = "d")
    public List<Map<String,Object>> selectRoleList(Map<String,Object> role) {
        return roleMapper.selectRoleList(role);
    }



    @Override
    public int addUsers(Map<String,Object> role) {
        List<String> userIds = (List<String>) role.get("userIds");
        roleMapper.deleteUserByRoleId(role.get("roleid")+"");
        List<String> sqlLists=new ArrayList<>();
        for (String userid : userIds) {
            sqlLists.add("insert into sys_t_user_role (user_id, role_id)\n" +
                    " values ('"+userid+"', '"+role.get("roleid")+"')");
        }
        commonMapper.batchExecuteSql(sqlLists);
        return 1;
    }

    /**
     * 通过角色ID查询角色
     *
     * @param roleId 角色ID
     * @return 角色对象信息
     */
    @Override
    public Map<String,Object> selectRoleById(String roleId) {
        return roleMapper.selectRoleById(roleId);
    }

    /**
     * 校验角色名称是否唯一
     *
     * @param role 角色信息
     * @return 结果
     */
    @Override
    public String checkRoleNameUniqueInster(Map<String,Object> role) {
        String roleId = StringUtils.isNull(role.get("roleId")) ? "-1" : role.get("roleId")+"";
        Map<String,Object> info = roleMapper.checkRoleNameUnique(role.get("roleName")+"");
        if (StringUtils.isNotNull(info) && !role.get("roleId").equals(roleId)) {
            return UserConstants.UNIQUE;
        }
        return UserConstants.NOT_UNIQUE;
    }


    /**
     * 校验角色名称是否唯一
     *
     * @param role 角色信息
     * @return 结果
     */
    @Override
    public String checkRoleNameUnique(Map<String,Object> role) {
        String roleId = StringUtils.isNull(role.get("roleId")) ? "-1" : role.get("roleId")+"";
        Map<String,Object> info = roleMapper.checkRoleNameUnique(role.get("roleName")+"");
        if (StringUtils.isNotNull(info) && !role.get("roleId").equals(roleId)) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验角色编码是否唯一
     *
     * @param role 角色信息
     * @return 结果
     */
    @Override
    public String checkRoleKeyUnique(Map<String,Object> role) {
        String roleId = StringUtils.isNull(role.get("roleId")) ? "-1" : role.get("roleId")+"";
        Map<String,Object> info = roleMapper.checkRoleKeyUnique(role.get("roleKey")+"");
        if (StringUtils.isNotNull(info) && !role.get("roleId").equals(roleId)) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }


    /**
     * 新增保存角色信息
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int insertRole(Map<String,Object> role) {
        // 新增角色信息
        roleMapper.insertRole(role);
        //新增角色菜单信息
        //insertRoleMenu(role);
        return 1;
    }

    /**
     * 新增角色菜单信息
     *
     * @param role 角色对象
     */
    public int insertRoleMenu(Map<String,Object> role) {
        List<String> menuIds = (List<String>) role.get("menuId");
        List<String> sqlLists=new ArrayList<>();
        // 新增用户与角色管理
        for (String menuid : menuIds) {
            sqlLists.add("insert into sys_role_menu (role_id, menu_id)\n" +
                    " values ('"+role.get("roleid")+"', '"+menuid+"')");
        }
        commonMapper.batchExecuteSql(sqlLists);
        return 1;
    }


    /**
     * 修改保存角色信息
     *
     * @param role 角色信息
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateRole(Map<String,Object> role) {
        // 修改角色信息
        roleMapper.updateRole(role);
        // 删除角色与菜单关联
        //commonMapper.executeSql("delete from sys_t_role_menu where role_id = '"+role.get("roleid")+"'");
        //insertRoleMenu(role);
        return 1;
    }

    /**
     * 根据角色ID查询已赋值菜单
     * @param roleId
     * @return
     */
    @Override
    public List<String> getByRoleId(String roleId) {
        List<String> byRoleId = roleMapper.getByRoleId(roleId);
        return byRoleId;
    }

    /**
     * 角色菜单
     * @param roleMenu
     * @return
     */
    @Override
    public void roleMenu(Map<String, Object> roleMenu) {

        //用户ID
        String roleId = (String) roleMenu.get("roleid");

        //角色ID
        List<String> menuIds = (List<String>) roleMenu.get("menuids");

        if (ObjectUtil.isEmpty(roleId)){
            throw new CustomException("角色ID不可为空");
        }

        if (ObjectUtil.isEmpty(menuIds)){
            throw new CustomException("菜单ID不可为空");
        }

        // 删除角色菜单关联
        commonMapper.executeSql("delete from sys_t_role_menu where role_id = '"+roleMenu.get("roleid")+"'");

        // 新增角色菜单关联
        insertRoleMenu(roleMenu);
    }

    /**
     * 查询所有角色
     *
     * @return 角色列表
     */
    @Override
    public List<Map<String,Object>> selectRoleAll() {
        List<Map<String,Object>> sysRoleList = roleMapper.selectRoleAll();
        return sysRoleList;
    }


    /**
     * 通过角色ID查询角色使用数量
     *
     * @param roleId 角色ID
     * @return 结果
     */
    @Override
    public Long countUserRoleByRoleId(String roleId) {
        return roleMapper.countUserRoleByRoleId(roleId);
    }


    /**
     * 修改角色状态
     *
     * @param role 角色信息
     * @return 结果
     */
    @Override
    public int updateRoleStatus(Map<String,Object> role) {
        return roleMapper.updateRole(role);
    }


    /**
     * 批量删除角色信息
     *
     * @param roleIds 需要删除的角色ID
     * @return 结果
     */
    @Override
    public int deleteRoleByIds(List<String> roleIds) {
        for (String roleId : roleIds) {
            Map<String,Object> role = selectRoleById(roleId);
            if (countUserRoleByRoleId(roleId) > 0) {
                throw new CustomException(String.format("%1$s已分配,不能删除", role.get("roleName")));
            }
        }
        return roleMapper.deleteRoleByIds(roleIds);
    }
}
